export const dataService = {
  // 服务器配置
  SERVER_CONFIG: {
    baseURL: 'https://torch.tianzi.info/api',
    timeout: 5000
  },

  // 价格相关的正则表达式模式
  PRICE_PATTERNS: {
    id: /XchgSearchPrice----SynId = (\d+).*?\+refer \[(\d+)\]/gs,
    value: /\+\d+\s+\[([\d.]+)\]/g
  },

  // 向服务器提交价格更新
  async submitPriceToServer(itemId, price, itemName = '') {
    try {
      const response = await fetch(`${this.SERVER_CONFIG.baseURL}/update_price`, {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
        },
        body: JSON.stringify({
          item_id: itemId,
          price: price,
          item_name: itemName
        })
      });

      const result = await response.json();
      if (result.success) {
        console.log(`价格已提交到服务器: ${itemName}(${itemId}) - ${price}`);
        return true;
      } else {
        console.error(`价格提交失败: ${result.error}`);
        return false;
      }
    } catch (error) {
      console.error('连接价格服务器失败:', error);
      return false;
    }
  },

  // 从服务器获取所有价格
  async fetchPricesFromServer() {
    try {
      const response = await fetch(`${this.SERVER_CONFIG.baseURL}/get_prices`, {
        method: 'GET',
        headers: {
          'Content-Type': 'application/json',
        }
      });

      if (!response.ok) {
        throw new Error(`HTTP error! status: ${response.status}`);
      }

      const serverPrices = await response.json();
      console.log(`从服务器获取到 ${Object.keys(serverPrices).length} 个物品价格`);
      return serverPrices;
    } catch (error) {
      console.error('从服务器获取价格失败:', error);
      return null;
    }
  },

  // 修改同步服务器价格到本地的方法
  async syncPricesFromServer() {
    try {
      // 从服务器获取价格数据
      const serverPrices = await this.fetchPricesFromServer();

      // 打印服务器返回的原始数据（用于调试）
      console.log('=== 服务器返回的价格数据 ===');
      console.log('服务器物品总数:', Object.keys(serverPrices || {}).length);
      // 打印前5条数据（避免日志过长）
      const serverEntries = Object.entries(serverPrices || {});
      const displayEntries = serverEntries.slice(0, 5);
      displayEntries.forEach(([itemId, serverData]) => {
        console.log(`[${itemId}] 名称: ${serverData.name || '未知'}, 价格: ${serverData.price}, 原始价格值:`, serverData.price);
      });
      if (serverEntries.length > 5) {
        console.log(`... 省略 ${serverEntries.length - 5} 条数据`);
      }

      // 验证服务器数据有效性
      if (!serverPrices || typeof serverPrices !== 'object') {
        console.log('未获取到有效的服务器价格数据');
        return false;
      }

      // 加载本地价格数据
      const localPrices = (await this.loadItemJson()) || {};
      console.log('=== 本地价格数据 ===');
      console.log('本地物品总数:', Object.keys(localPrices).length);

      let updatedCount = 0;
      const changedItems = []; // 记录变动的物品

      // 遍历服务器价格，对比本地价格
      serverEntries.forEach(([itemId, serverData]) => {
        // 确保服务器数据包含价格字段
        if (!serverData || serverData.price === undefined) {
          console.log(`[跳过] 物品 ${itemId} 服务器数据缺少价格`);
          return;
        }

        // 解析价格为数值（处理字符串/数字差异）
        const localPrice = localPrices[itemId] ? parseFloat(localPrices[itemId].price) : null;
        const serverPrice = parseFloat(serverData.price);
        const itemName = serverData.name || localPrices[itemId]?.name || `未知物品(${itemId})`;

        // 打印单物品对比详情
        console.log(
          `[对比] ${itemName}(${itemId}): ` +
          `本地价格=${localPrice} (类型: ${typeof localPrice}), ` +
          `服务器价格=${serverPrice} (类型: ${typeof serverPrice}), ` +
          `是否一致: ${localPrice === serverPrice}`
        );

        // 价格不一致或本地无记录时更新
        if (localPrice === null || localPrice !== serverPrice) {
          changedItems.push({
            itemId,
            itemName,
            localPrice: localPrice ?? '无记录',
            serverPrice
          });

          // 更新本地价格数据
          const existingName = localPrices[itemId]?.name;
          localPrices[itemId] = {
            ...localPrices[itemId], // 保留其他属性
            price: serverData.price, // 覆盖价格
            last_update: new Date().getTime(), // 更新时间戳
            from: 'server', // 标记来源
            name: serverData.name || existingName || `未知物品(${itemId})`
          };
          updatedCount++;
        }
      });

      // 打印变动详情
      if (changedItems.length > 0) {
        console.log('\n=== 价格变动详情 ===');
        changedItems.forEach(item => {
          console.log(`[${item.itemId}] ${item.itemName}`);
          console.log(`  本地旧价格: ${item.localPrice}`);
          console.log(`  服务器新价格: ${item.serverPrice}\n`);
        });
      }

      // 有更新时保存并同步 priceData（关键修改）
      if (updatedCount > 0) {
        // 用新方法：保存文件 + 刷新 priceData
        const saveSuccess = await this.saveFullTableAndRefresh(localPrices);
        if (saveSuccess) {
          console.log(`价格同步完成: 共更新 ${updatedCount} 个物品价格（服务器数据为准）`);
        } else {
          console.error('价格同步失败：保存文件后未能刷新 priceData');
        }
      } else {
        console.log('价格同步完成: 本地价格与服务器完全一致，无需更新');
      }
      // 强制更新内存价格表
      console.log('准备更新内存价格表...');
      console.log(this.priceData);
      
      this.updatePriceTable(this.priceData);

      // 无论是否有更新，强制重新计算（确保面板使用最新数据）
      if (this.items !== undefined) {
        console.log('强制重新计算所有物品价值...');
        this.recalculateAllValues();
      }

      // 触发更新事件
      if (typeof this.onPricesUpdated === 'function' && updatedCount > 0) {
        this.onPricesUpdated(localPrices);
      }

      return true;
    } catch (error) {
      console.error('价格同步失败:', error);
      return false;
    }
  },
  // 修改updatePriceTable方法，增加安全检查
  updatePriceTable(prices) {
  this.priceTable = this.priceTable || {};
  if (prices && typeof prices === 'object') {
    Object.entries(prices).forEach(([id, itemData]) => {
      if (id && itemData && itemData.price !== undefined) {
        const oldPrice = this.priceTable[id];
        const newPrice = parseFloat(itemData.price) || 0;
        this.priceTable[id] = newPrice;
        if (oldPrice !== newPrice) {
          console.log(`[内存价格更新] ${id}: 旧值=${oldPrice}, 新值=${newPrice}`);
        }
      }
    });
  }

  // 新增：验证100200是否已正确更新到priceTable
  console.log(`[价格表验证] 100200的当前价格: ${this.priceTable['100200'] || '未找到'}`);
  console.log('内存价格表已更新（服务器数据为准）');
},

  // 修改recalculateAllValues方法，添加安全检查
  recalculateAllValues() {
  if (!this.items || !this.priceTable) {
    console.log('物品列表或价格表未初始化，跳过计算');
    return;
  }

  this.items.forEach(item => {
    // 打印物品ID的类型和值
    console.log(`[计算验证] 物品ID: ${item.id} (类型: ${typeof item.id}), priceTable中是否存在: ${item.id in this.priceTable}`);
    
    if (item.id && this.priceTable[item.id] !== undefined) {
      const oldValue = item.totalValue;
      item.totalValue = item.count * this.priceTable[item.id];
      if (oldValue !== item.totalValue) {
        console.log(`[计算更新] ${item.name} x${item.count}: 旧值=${oldValue}, 新值=${item.totalValue}`);
      }
    } else {
      // 重点关注：为什么没找到价格
      console.warn(`[计算警告] 物品 ${item.name}(${item.id}) 未在priceTable中找到价格，使用默认值0`);
    }
  });

  console.log('所有物品价值已重新计算');
},

  // 强化updateProfitImmediately方法，确保使用最新价格
  updateProfitImmediately() {
    // 重新计算当前地图收益
    const currentValue = Object.entries(this.dropList || {}).reduce((sum, [id, count]) => {
      return sum + (this.priceTable[id] || 0) * count;
    }, 0);

    // 重新计算总收益
    const totalValue = Object.entries(this.dropListAll || {}).reduce((sum, [id, count]) => {
      return sum + (this.priceTable[id] || 0) * count;
    }, 0);

    // 更新收益（保留3位小数）
    this.currentProfitValue = parseFloat((currentValue - parseFloat(this.costPerMap || 0)).toFixed(3));
    this.totalProfitValue = parseFloat((totalValue - this.totalCost).toFixed(3));

    // 强制Vue更新界面（针对计算属性）
    this.$forceUpdate();
  },

  // 在recordPickedItem方法中确保使用最新价格（双重保险）
  recordPickedItem(code, count) {
    const itemInfo = this.fullTable[code] || {};
    // 直接从priceTable获取价格（已通过updatePriceTable同步最新值）
    const itemPrice = this.priceTable[code] || 0;
    const totalValue = parseFloat((itemPrice * count).toFixed(3));

    const item = {
      id: code,
      name: itemInfo.name || `未知物品(${code})`,
      count: count,
      price: itemPrice, // 使用最新价格
      totalValue: totalValue,
      timestamp: new Date().getTime()
    };

    this.items.push(item);
    console.log(`拾取: ${item.name} x${count}，价值: ${totalValue}`);

    this.updateDropStatistics(code, count);
  },

  // 检查服务器健康状态
  async checkServerHealth() {
    try {
      const response = await fetch(`${this.SERVER_CONFIG.baseURL}/health`);
      const result = await response.json();
      return result.status === 'ok';
    } catch (error) {
      return false;
    }
  },

  // 修改原有的价格处理函数，添加服务器提交
  async processPriceInfo(text) {
    try {
      const idMatches = [...text.matchAll(this.PRICE_PATTERNS.id)]

      if (idMatches.length === 0) return

      for (const match of idMatches) {
        const synid = match[1]
        const itemId = match[2]

        // 跳过特定ID
        if (parseInt(itemId) === 100300) continue

        // 提取价格数据块
        const priceBlockPattern = new RegExp(
          `----Socket RecvMessage STT----XchgSearchPrice----SynId = ${synid}\\s+` +
          `\\[.*?\\]\\s*GameLog: Display: \\[Game\\]\\s+` +
          `(.*?)(?=----Socket RecvMessage STT----|$)`,
          'gs'
        )

        const priceMatch = priceBlockPattern.exec(text)
        if (!priceMatch) continue

        const dataBlock = priceMatch[1]
        const valueMatches = [...dataBlock.matchAll(this.PRICE_PATTERNS.value)]
        const values = valueMatches.map(m => parseFloat(m[1]))

        // 计算平均价格
        let averageValue = -1
        if (values.length > 0) {
          const numValues = Math.min(values.length, 30)
          const sumValues = values.slice(0, numValues).reduce((sum, val) => sum + val, 0)
          averageValue = sumValues / numValues
        }

        // 更新本地价格表
        await this.updateLocalPriceTable(itemId, averageValue)

        // 同时提交到服务器
        const fullTable = await this.loadItemJson();
        const itemName = fullTable[itemId]?.name || '';
        await this.submitPriceToServer(itemId, averageValue, itemName);

        console.log(`更新物品价格: ID:${itemId}, 价格:${averageValue.toFixed(4)}`)
      }
    } catch (error) {
      console.error('处理价格信息失败:', error)
    }
  },

  // 修改更新本地价格表函数
  async updateLocalPriceTable(itemId, price) {
    try {
      const fullTable = await this.loadItemJson()

      if (fullTable[itemId]) {
        fullTable[itemId].last_time = Math.floor(Date.now() / 1000)
        fullTable[itemId].from = "Local"
        fullTable[itemId].price = parseFloat(price.toFixed(4))

        await this.saveFullTable(fullTable)

        console.log(`价格表已更新: ${fullTable[itemId]?.name || '未知物品'} (${itemId}) - ${price.toFixed(4)}`)
      }
    } catch (error) {
      console.error('更新本地价格表失败:', error)
    }
  },

  // 启动定时同步
  startPriceSync(interval = 60000) { // 默认1分钟
    if (this.syncInterval) {
      clearInterval(this.syncInterval);
    }

    this.syncInterval = setInterval(async () => {
      const isHealthy = await this.checkServerHealth();
      if (isHealthy) {
        await this.syncPricesFromServer();
      } else {
        console.log('价格服务器不可用，跳过同步');
      }
    }, interval);

    console.log(`价格同步已启动，间隔: ${interval}ms`);
  },

  // 停止定时同步
  stopPriceSync() {
    if (this.syncInterval) {
      clearInterval(this.syncInterval);
      this.syncInterval = null;
      console.log('价格同步已停止');
    }
  },

  // 计算速率
  calculateRate(time, items, priceData) {
    if (time < 60) return '0.00'

    let totalValue = 0
    items.forEach(item => {
      const price = priceData[item.name] || 0
      totalValue += price * item.count
    })

    const minutes = Math.floor(time / 60)
    return (totalValue / minutes).toFixed(2)
  },

  // 计算收益
  calculateProfit(items, priceData, totalCost) {
    let totalValue = 0
    items.forEach(item => {
      const price = priceData[item.name] || 0
      totalValue += price * item.count
    })
    return totalValue - totalCost
  },

  // 创建随机物品
  createRandomItem(itemList, existingItems) {
    const now = new Date()
    const timeString = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`
    const randomItem = itemList[Math.floor(Math.random() * itemList.length)]

    // 检查物品是否已存在
    const existingItem = existingItems.find(item => item.id === randomItem.id)
    const count = existingItem ? existingItem.count + 1 : 1

    return {
      id: randomItem.id,
      name: randomItem.name,
      time: timeString,
      count
    }
  },

  // 同步修改时的保存方法也需要对应修改（确保保存到同一路径）
  async saveFullTable(data) {
    try {
      const { ipcRenderer, remote } = window.require('electron');
      const path = window.require('path');
      const { app } = remote;

      let filePath;
      if (process.env.NODE_ENV === 'development') {
        filePath = path.join(process.cwd(), 'public', 'assets', 'item.json');
      } else {
        filePath = path.join(process.resourcesPath, 'public', 'assets', 'item.json');
      }

      // 关键修改：使用 file:mkdir 代替 dir:ensure
      const dirPath = path.dirname(filePath);
      const mkdirResult = await ipcRenderer.invoke('file:mkdir', dirPath);
      if (!mkdirResult.success) {
        throw new Error(`创建目录失败: ${mkdirResult.error}`);
      }

      // 写入数据（使用已有的 file:write 事件）
      const writeSuccess = await ipcRenderer.invoke('file:write', filePath, JSON.stringify(data, null, 2));
      if (!writeSuccess) {
        throw new Error('写入文件失败');
      }

      console.log(`价格表已保存到: ${filePath}`);
      return true;
    } catch (error) {
      console.error('保存 item.json 失败:', error);
      return false;
    }
  },

  async saveFullTableAndRefresh(data) {
    try {
      // 1. 保存到本地文件
      const success = await this.saveFullTable(data);
      if (!success) {
        throw new Error('保存文件失败');
      }
      // 2. 重新加载 priceData（关键：同步本地文件的最新内容）
      this.priceData = await this.loadItemJson();
      console.log('本地文件保存成功，已同步更新 priceData');
      return true;
    } catch (error) {
      console.error('保存并刷新 priceData 失败:', error);
      return false;
    }
  },

  // 加载物品数据
  async loadItemJson() {
    try {
      const { ipcRenderer, remote } = window.require('electron');
      const path = window.require('path');
      const { app } = remote;

      // 1. 确定当前环境的正确路径（核心修改）
      let filePath;
      if (process.env.NODE_ENV === 'development') {
        // 开发环境：直接使用项目public目录下的item.json（可读写）
        filePath = path.join(process.cwd(), 'public', 'assets', 'item.json');
      } else {
        // 生产环境：使用asar外部的item.json（通过asarUnpack配置的路径）
        // 路径对应：应用目录/resources/public/assets/item.json
        filePath = path.join(process.resourcesPath, 'public', 'assets', 'item.json');
      }

      // 2. 检查文件是否存在
      let fileExists = await ipcRenderer.invoke('file:exists', filePath);

      // 3. 若文件不存在，初始化默认数据并创建文件
      if (!fileExists) {
        console.warn(`未找到${filePath}，创建默认文件`);
        const defaultData = {
          "1001": {
            "name": "星星蛾火",
            "type": "记忆荧光",
            "price": 2797.267,
            "last_update": 1760992974,
            "from": "10703f5d-216a-40a8-b74b-059b1dac7206"
          }
        };
        // 写入默认数据到目标路径（确保可读写）
        await ipcRenderer.invoke('file:write', filePath, JSON.stringify(defaultData, null, 2));
        return defaultData;
      }

      // 4. 读取并返回文件内容
      const content = await ipcRenderer.invoke('file:read', filePath);
      return JSON.parse(content);

    } catch (error) {
      console.error('加载 item.json 失败:', error);
      return {};
    }
  },

  // 窗口控制
  disableWindowResize() {
    if (window.require) {
      try {
        const { remote } = window.require('electron')
        const currentWindow = remote.getCurrentWindow()
        currentWindow.setResizable(false)
      } catch (error) {
        console.error('禁止窗口调整大小失败:', error)
      }
    }
  },

  applyWindowOpacity(opacity) {
    if (window.require) {
      try {
        const { remote } = window.require('electron')
        const currentWindow = remote.getCurrentWindow()
        currentWindow.setOpacity(opacity / 100)
      } catch (error) {
        console.error('设置窗口透明度失败:', error)
      }
    }
  },

  // 设置管理
  loadSettings() {
    try {
      const settings = localStorage.getItem('appSettings')
      return settings ? JSON.parse(settings) : {}
    } catch (error) {
      console.error('加载设置失败:', error)
      return {}
    }
  },

  saveSettings(settings) {
    try {
      localStorage.setItem('appSettings', JSON.stringify(settings))
    } catch (error) {
      console.error('保存设置失败:', error)
    }
  },

  // 通用方法
  commonMethods: {
    hideScrollbar() {
      this.$nextTick(() => {
        const itemsList = this.$refs.itemsList
        if (itemsList) {
          itemsList.style.scrollbarWidth = 'none'
          itemsList.style.msOverflowStyle = 'none'
        }
      })
    },

    resetRunning() {
      this.isRunning = false
      this.currentTime = 0
      this.mapCount = 0
      this.totalCost = 0
      this.stopAllIntervals()
    }
  }
}